package dq.study.java.grammar.generator;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @author dongqun
 * @version 1.0.0
 * @since 2021/09/26 14:04:00
 */
public class AccessibleTest extends Person<Long> implements SuperPerson<Person> {
    private int id = 1;
    private String name = "网";

    public AccessibleTest() {
//        System.out.println("accesible Test");
    }

    public int getId() {
        return id;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void saySuperPerson(Person t) {
        System.out.println(t);
    }

    public static void main(String[] args) {
        Class clazz = AccessibleTest.class;
        AccessibleTest a = new AccessibleTest();
        clazz = a.getClass();
        Type genType = clazz.getGenericSuperclass(); //得到这个类的父类 的参数类型


        if (genType instanceof ParameterizedType) { //如果是 泛型的参数类型 ，就得到泛型类型
            Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); //强转换为参数类型
            for(Type t : params ){
                System.out.println( t );
            }
            System.out.println( "==========");
        }

        //得到接口的泛型类型
        Type[] type1 = clazz.getGenericInterfaces();
        if( type1!=null && type1.length>0 ){
            for(int i=0;i<type1.length;i++ ){ //循环泛型类型

                //如果得到的泛型类型是 ParameterizedType（参数化类型）类型的话
                if(ParameterizedType.class.isAssignableFrom( type1[i].getClass()  )  ){
                    ParameterizedType ptype = (ParameterizedType)type1[i];//将类型转换为 参数类型类
                    Type[] iType = ptype.getActualTypeArguments(); //得到  泛型类型的实际  类型
                    for(Type p1 : iType){
                        System.out.println(p1 +"=======" );
                    }
                }
            }
        }
    }
}
